class NetworkCache {
    constructor() {
        this.cache = new Map(); // 使用Map存储缓存项
        this.timers = new Map(); // 存储定时器
        this.apiMap = new Map(); // 按类型分类缓存
        this.disableCache = false;  // 是否关闭缓存
    }

    /**
     * 设置缓存
     * @param {string} api API
     * @param {string} key 缓存键请求地址
     * @param {any} value 缓存值
     * @param {object} options 配置项
     * @param {number} [options.expire=10*60*1000] 过期时间(ms)，默认10分钟
     * @param {string} [options.api] 缓存类型
     */
    set(api, key, value, options = {}) {
        if (this.disableCache) {
            return;
        }
        const { expire = 10 * 60 * 1000 } = options;
        const expireTime = Date.now() + expire;

        // 清除旧定时器（如果存在）
        if (this.timers.has(key)) {
            clearTimeout(this.timers.get(key));
        }

        // 设置新缓存
        this.cache.set(key, { value, expireTime, api });

        // 设置定时清理
        this.timers.set(key, setTimeout(() => {
            this.delete(key);
        }, expire));

        // 按类型分类
        if (api) {
            if (!this.apiMap.has(api)) {
                this.apiMap.set(api, new Set());
            }
            this.apiMap.get(api).add(key);
        }

        return true;
    }

    /**
     * 获取缓存
     * @param {string} key 缓存键
     * @returns {any|null} 缓存值或null
     */
    get(key) {
        if (!this.cache.has(key)) return null;

        const item = this.cache.get(key);
        if (Date.now() > item.expireTime) {
            this.delete(key);
            return null;
        }

        return item.value;
    }

    /**
     * 删除缓存
     * @param {string} key 缓存键
     */
    delete(key) {
        if (this.cache.has(key)) {
            const item = this.cache.get(key);

            // 清除定时器
            if (this.timers.has(key)) {
                clearTimeout(this.timers.get(key));
                this.timers.delete(key);
            }

            // 从类型分类中移除
            if (item.api && this.apiMap.has(item.api)) {
                this.apiMap.get(item.api).delete(key);
                if (this.apiMap.get(item.api).size === 0) {
                    this.apiMap.delete(item.api);
                }
            }

            // 从缓存中移除
            this.cache.delete(key);
        }
    }

    /**
     * 清除指定类型的所有缓存
     * @param {string} api 缓存类型
     */
    clearByApi(api) {
        if (this.apiMap.has(api)) {
            const keys = Array.from(this.apiMap.get(api));
            keys.forEach(key => this.delete(key));
            this.apiMap.delete(api);
        }
    }

    /**
     * 清除所有缓存
     */
    clearAll() {
        this.cache.forEach((_, key) => this.delete(key));
        this.apiMap.clear();
    }

    /**
     * 获取指定类型的所有缓存键
     * @param {string} api 缓存类型
     * @returns {array} 缓存键数组
     */
    getKeysByApi(api) {
        return this.apiMap.has(api)
            ? Array.from(this.apiMap.get(api))
            : [];
    }

    /**
     * 获取缓存信息（调试用）
     */
    getCacheInfo() {
        return {
            size: this.cache.size,
            apis: Array.from(this.apiMap.keys()),
            entries: Array.from(this.cache.entries())
        };
    }
}

// 创建单例实例
const networkCache = new NetworkCache();

export default networkCache;